import java.util.*;

/**
 * @author LKQ
 * @date 2022/4/22 16:03
 * @description 记忆化DFS 访问到一个单元格 (i,j) 时，
 * 如果 memo[i][j] 不等于 0，说明该单元格的结果已经计算过，则直接从缓存中读取结果，
 * 如果 memo[i][j]=0，说明该单元格的结果尚未被计算过，则进行搜索，并将计算得到的结果存入缓存中。
 */
public class Solution2 {
    public static void main(String[] args) {
        Solution2 solution2 = new Solution2();
        int[][] mat = {{9, 9, 4}, {6, 6, 8}, {2, 1, 1}};
        solution2.longestIncreasingPath(mat);
    }

    public int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    public int rows, columns;

    public int longestIncreasingPath(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        rows = matrix.length;
        columns = matrix[0].length;
        int[][] memo = new int[rows][columns];
        int ans = 0;
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < columns; ++j) {
                ans = Math.max(ans, dfs(matrix, i, j, memo));
            }
        }
        return ans;
    }

    public int dfs(int[][] matrix, int x, int y, int[][] memo) {
        if (memo[x][y] != 0) {
            return memo[x][y];
        }
        ++memo[x][y];
        for (int[] dir : dirs) {
            int nx = x + dir[0], ny = y + dir[1];
            if (nx >= 0 && nx < rows && ny >= 0 && ny < columns && matrix[nx][ny] > matrix[x][y]) {
                memo[x][y] = Math.max(memo[x][y], dfs(matrix, nx, ny, memo) + 1);
            }
        }
        return memo[x][y];
    }
}
